package cn.atzxc.qy.service.impl;

import cn.atzxc.qy.domain.Address;
import cn.atzxc.qy.domain.Task;
import cn.atzxc.qy.domain.User;
import cn.atzxc.qy.domain.vo.TaskVo;
import cn.atzxc.qy.mapper.AddressMapper;
import cn.atzxc.qy.mapper.TaskMapper;
import cn.atzxc.qy.mapper.UserMapper;
import cn.atzxc.qy.service.TaskService;
import cn.atzxc.qy.utils.JwtUtil;
import cn.atzxc.qy.utils.NumberGenerator;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.sql.Timestamp;
import java.util.Date;
import java.util.List;

@Service
public class TaskServiceImpl implements TaskService {

    @Autowired
    private TaskMapper taskMapper;
    @Autowired
    private UserMapper userMaper;
    @Autowired
    private AddressMapper addressMapper;

    @Override
    public List<TaskVo> getTaskList(String token, Long categoryId) throws Exception {
        //1.获取用户ID
        Claims claims = JwtUtil.parseJWT(token);
        String subject = claims.getSubject();
        Long userid = Long.parseLong(subject);//封装成为一个long类型
        System.out.println("解析出的ID为："+userid);
        //2.通过前端传递的用户ID然后查询出学校
        LambdaQueryWrapper<User> queryWrapperUser = new LambdaQueryWrapper<>();
        queryWrapperUser.eq(User::getUser_id, userid);//查询出指定用户的学校
        User user = userMaper.selectOne(queryWrapperUser);

        if(user.getUniversity() == null){
            return null;
        }

        //已经获取到大学了,当用户ID不等于自己用户
        List<TaskVo> taskVos = taskMapper.selectListByUniversityAndCategory(user.getUniversity(), categoryId,userid);
        //根据其中一个地址ID获取地址的详细信息
        for (TaskVo taskVo : taskVos) {
            //根据起始地址ID查询出起始地址
            String taskHomeaddressId = taskVo.getTaskHomeaddressId();
            LambdaQueryWrapper<Address> q1 = new LambdaQueryWrapper<>();
            q1.eq(Address::getAddressId,taskHomeaddressId);
            Address address1 = addressMapper.selectOne(q1);
            taskVo.setAddressHome(address1);
            //根据终点地址ID查询出终点地址
            String taskGoaddressId = taskVo.getTaskGoaddressId();
            LambdaQueryWrapper<Address> q2 = new LambdaQueryWrapper<>();
            q2.eq(Address::getAddressId,taskGoaddressId);
            Address address2 = addressMapper.selectOne(q2);
            taskVo.setAddressGo(address2);
        }

        return taskVos;
    }

    /**
     * 插入一个商品
     * 1.获取到用户的发布的商品信息
     * 2.封装数据
     *      - 通过token获取到用户ID，封装到user_id中
     *      -  ！通过user_id 在userid的表中获取到所属大学
     *      - 随机生成一个任务编号，封装到taskCode中
     *      - 计算价格（也可能是直接定死价格）
     *      - 默认是待支付状态
     *      - 设置taskStartTime发布时间
     *      - 如果体积大小为空 则设置为默认为小件
     *
     * @param token
     * @param task
     * @return
     */
    @Override
    public String addTask(String token,Task task) throws Exception {

        System.out.println("接收到的task:"+task);
        //1.解析出用户ID
        Claims claims = JwtUtil.parseJWT(token);
        String subject = claims.getSubject();
        Long userid = Long.parseLong(subject);//封装成为一个long类型
        System.out.println("解析出的ID为："+userid);
        task.setUserId(userid);

        //封装任务所属大学
        LambdaQueryWrapper<User> queryWrapperUser = new LambdaQueryWrapper<>();
        queryWrapperUser.eq(User::getUser_id, userid);//查询出指定用户的学校
        User user = userMaper.selectOne(queryWrapperUser);
        System.out.println("用户:"+user);
        if(!user.getUniversity().equals("") || user.getUniversity() != null ){
            task.setTaskUniversity(user.getUniversity());
        }
        if(user.getUniversity().length() == 0){//如果用户没有学校

            return "error";
        }


        //2.创建一个任务编号
        String taskCode = NumberGenerator.generateOrderNumber();
        task.setTaskCode(taskCode);
        //3.计算价格
        //4.设置状态为待支付状态
        task.setTaskStatus("未付款");
        //5.设置发布时间为当前时间
        Date date = NumberGenerator.generateCurrentDateTime();
        task.setTaskStartTime(date);
        //6.设置物品体积
        if(task.getTaskSize() == null){
            task.setTaskSize("小件");
        }
        if(task.getTaskSize().equals("large")){
            task.setTaskSize("大件");
        }else if (task.getTaskSize().equals("small")) {
            task.setTaskSize("小件");
        }else if(task.getTaskSize().equals("medium")){
            task.setTaskSize("中件");
        }
        if(task.getTaskImageurl().length() == 0){
            task.setTaskImageurl(null);
        }

        //TODO 判断地址是否为空
        System.out.println("接收到的task数据："+task);

        //执行插入
        int insert = taskMapper.insert(task);
        if(insert > 0){
            System.out.println("插入成功");
            return taskCode;
        }

        return String.valueOf(insert);
    }

    @Override
    public List<TaskVo> getMyTaskList(String token) throws Exception {
        //1.获取用户ID
        Claims claims = JwtUtil.parseJWT(token);
        String subject = claims.getSubject();
        Long userid = Long.parseLong(subject);//封装成为一个long类型
        System.out.println("解析出的ID为："+userid);

        List<TaskVo> taskVos = taskMapper.selectMyTaskList(userid);
        //根据其中一个地址ID获取地址的详细信息
        for (TaskVo taskVo : taskVos) {
            //根据起始地址ID查询出起始地址
            String taskHomeaddressId = taskVo.getTaskHomeaddressId();
            LambdaQueryWrapper<Address> q1 = new LambdaQueryWrapper<>();
            q1.eq(Address::getAddressId,taskHomeaddressId);
            Address address1 = addressMapper.selectOne(q1);
            taskVo.setAddressHome(address1);
            //根据终点地址ID查询出终点地址
            String taskGoaddressId = taskVo.getTaskGoaddressId();
            LambdaQueryWrapper<Address> q2 = new LambdaQueryWrapper<>();
            q2.eq(Address::getAddressId,taskGoaddressId);
            Address address2 = addressMapper.selectOne(q2);
            taskVo.setAddressGo(address2);
        }

        return taskVos;



    }



    /**
     * 通过任务ID获取当前任务
     * 1.将token解析出userid
     * 2.通过taskCode查询出指定的条目
     * 3.判断任务对象中的userid和解析出的数据是否相同，如果相同，则返回，否则返回空
     * @param token
     * @param taskCode
     * @return
     */
    @Override
    public TaskVo getTaskById(String token, String taskCode) throws Exception {
        //1.解析出用户ID
        Claims claims = JwtUtil.parseJWT(token);
        String subject = claims.getSubject();
        Long userid = Long.parseLong(subject);//封装成为一个long类型
        System.out.println("解析出的ID为："+userid);
        System.out.println("taskCode:"+taskCode);
        //2.通过taskCode查询出指定的条目
        TaskVo taskVo = taskMapper.selectTaskVoByCode(taskCode);
        if(userid.equals(taskVo.getUserId())){
            System.out.println("是同一个用户");
            //赋值地址信息
            //根据起始地址ID查询出起始地址
            String taskHomeaddressId = taskVo.getTaskHomeaddressId();
            LambdaQueryWrapper<Address> q1 = new LambdaQueryWrapper<>();
            q1.eq(Address::getAddressId,taskHomeaddressId);
            Address address1 = addressMapper.selectOne(q1);
            taskVo.setAddressHome(address1);
            //根据终点地址ID查询出终点地址
            String taskGoaddressId = taskVo.getTaskGoaddressId();
            LambdaQueryWrapper<Address> q2 = new LambdaQueryWrapper<>();
            q2.eq(Address::getAddressId,taskGoaddressId);
            Address address2 = addressMapper.selectOne(q2);
            taskVo.setAddressGo(address2);

            return taskVo;
        }

        return null;

    }
    /**
     * 未付款 -> 待接单
     * 1.根据token解析出用户的ID
     * 2.根据任务ID，判断当前任务是否属于此用户
     *          属于 && 任务状态为未付款 ，则将订单状态修改为待接单，就是已经付款了
     *          属于 && 任务状态不是未付款，返回-2
     *          如果不属于，则返回-3，表示当前订单不是此用户的
     * @param token
     * @return
     */
    @Override
    public int upTaskPayStatus(String token, String taskCode) {

        LambdaUpdateWrapper<Task> updateWrap = new LambdaUpdateWrapper<>();
        updateWrap.eq(Task::getTaskCode, taskCode);
        updateWrap.set(Task::getTaskStatus,"待接单");
        int update = taskMapper.update(null, updateWrap);

        return update;
    }

    @Override
    public int upTaskPayStatusCancel(String token, String taskCode) {

        LambdaUpdateWrapper<Task> updateWrap = new LambdaUpdateWrapper<>();
        updateWrap.eq(Task::getTaskCode, taskCode);
        updateWrap.set(Task::getTaskStatus,"已取消");
        int update = taskMapper.update(null, updateWrap);

        return update;
    }


}
